Developer CD Series 2000 November: Tool Chest/Dev.CD Nov 00 TC Disk 1.toast/Sample Code/Games/SprocketInvaders/Source/SpaceInvaders.c

Text File | 2000-09-28 | 19.7 KB | 926 lines | [TEXT/MPS ]

//•    ------------------------------------------------------------------------------------------    •
//•
//•        Copyright ©1995, Chris De Salvo
//•        Not to be distributed without expressed consent
//•
//•        Written by Chris De Salvo
//•
//•    ------------------------------------------------------------------------------------------    •

//•    ------------------------------    Includes

#include <Fonts.h>
#include <stdio.h>
#include <string.h>

#include "ErrorHandler.h"
#include "EventHandler.h"
#include "GameObject.h"
#include "Graphics.h"
#include "ObjectActions.h"
#include "SIResources.h"
#include "SoundHandler.h"
#include "SpaceInvaders.h"
#include "Sprite.h"
#include "NetSprocketSupport.h"
#include "CommonStuff.h"

//•    ------------------------------    Private Definitions

//#define RAND(x)                    ((Random() & 0x7FFF) % (x))

#define kPlayerVelocity                2L    //•    Speed at which player moves
#define kPlayerShotVelocity            6L    //•    Speed at which player shots travel
#define kPointsVelocity                -2L    //•    Vertical speed of the "points" object (negative is up)
#define kEnemyVelocity                5L    //•    Speed at which enemies move
#define kEnemyShotVelocity            4L    //•    Speed at which enemy shots drop

#define kEnemyOffset                8    //•    Space between columns of enemies

//•    ------------------------------    Private Types

enum
{
    scPlayer,
    scPlayer2,
    scPlayerShot,
    scPoints,
    scEnemy,
    scEnemyShot,
    scNumSprites
};

//•    ------------------------------    Private Variables

static SpritePtr    gSpriteCache[scNumSprites];    //•    Sprite artwork is cached here so that multiple items using
                                                //•    the same artwork only need one copy.
static long                gScore;
static short            gWave;
static short            gEnemyGas;
static int                gEnemyNewDirection;
static unsigned long    gFrameRateBaseTime;        //•    Base time for this game to count frame rate

float gGreenAccum;
float gRedAccum;

extern int gMyRand;
extern int gHisRand;
extern int gMyCallsToRand;
extern int gHisCallsToRand;

//•    ------------------------------    Private Functions

static void AddPlayers(void);
static void AddEnemies(void);
static void CollideShotsToEnemies(void);
static void AddPoints(short x, short y);
static void DisplayGameOver(CGrafPtr backBuff);
static void DropEnemies(void);
static void CollideShotsToPlayers(void);
static void AdvanceEnemies(void);
static void DisplayFrameRate(void);
static void EndGame(CGrafPtr backBuff);
static void GetGreenInput(void);
static void GetRedInput(void);

//•    ------------------------------    Public Variables

Boolean    gGameInProgress = false;
Boolean    gTwoPlayers = false;

GameObjectPtr    gEnemyList = nil;
GameObjectPtr    gEnemyShotList = nil;
GameObjectPtr    gPlayerList = nil;
GameObjectPtr    gGreenPlayerShotList = nil;
GameObjectPtr     gRedPlayerShotList = nil;
GameObjectPtr    gMiscObjectList = nil;

int        gEnemyTask;
int        gEnemiesChangeDirection;
short    gEnemyVelocity;
short    gNumEnemies;

unsigned long    gEnemyLevel;
unsigned long    gNumEnemiesProcessed;

int            gNumGreenPlayerLives = 0;
int            gNumRedPlayerLives = 0;

Boolean            gNetPlay;
extern Boolean    gReceivedInput;

//•    --------------------    InitNewGame

static void InitNewRound(short wave)
{
    GameObjectDisposeList(&gEnemyList);
    GameObjectDisposeList(&gEnemyShotList);
    GameObjectDisposeList(&gPlayerList);
    GameObjectDisposeList(&gGreenPlayerShotList);
    GameObjectDisposeList(&gRedPlayerShotList);
    GameObjectDisposeList(&gMiscObjectList);

    AddPlayers();
    AddEnemies();

    gEnemyTask = kEnemyMovingRight;
    gEnemiesChangeDirection = 0;
    gEnemyVelocity = kEnemyVelocity;
    gEnemyLevel = 1;
    gWave = wave;
}

static void NextRound(void)
{
    InitNewRound(gWave + 1);
}


void
InitNewGame(short wave)
{
    int i;

    for (i = 0; i < numInputs; i++)
        ISpElement_Flush(gInputElements[i]);

    gGreenAccum = 0;
    gRedAccum = 0;

    gGameInProgress = true;
    gScore = 0L;

    gFrameRateBaseTime = 0L;

    for (i = 0; i < scNumSprites; i++)
        SpriteDispose(&(gSpriteCache[i]));

    gSpriteCache[scPlayer] = SpriteLoad(kSPRTPlayer);
    if (! gSpriteCache[scPlayer])
        FatalError("Could not load player tank.");

    gSpriteCache[scPlayer2] = SpriteLoad(kSPRTPlayer2);
    if (! gSpriteCache[scPlayer])
        FatalError("Could not load player 2 tank.");

    gSpriteCache[scPlayerShot] = SpriteLoad(kSPRTPlayerShot);
    if (! gSpriteCache[scPlayerShot])
        FatalError("Could not load player shot.");

    gSpriteCache[scPoints] = SpriteLoad(kSPRTPoints);
    if (! gSpriteCache[scPoints])
        FatalError("Could no load points.");

    gSpriteCache[scEnemy] = SpriteLoad(kSPRTEnemy);
    if (! gSpriteCache[scEnemy])
        FatalError("Could no load enemy.");

    gSpriteCache[scEnemyShot] = SpriteLoad(kSPRTEnemyShot);
    if (! gSpriteCache[scEnemyShot])
        FatalError("Could no load enemy shot.");


    gNumGreenPlayerLives = 3;

    if (gTwoPlayers)
        gNumRedPlayerLives = 3;
    else
        gNumRedPlayerLives = 0;

    GraphicsActive();

    ISpResume();

    InitNewRound(wave);
}

//•    --------------------    GameLoop

void
GameLoop()
{
CGrafPtr            backBuff;
    ISpElementEvent    event;
    Boolean            wasEvent;

    if (gNetPlay)
    {
        if (gIAmHost)
        {
            GetGreenInput();
            SendInputState(gGameKeys.greenLeft, gGameKeys.greenRight, gGameKeys.greenFire);
            GetRedInput();
        }
        else
        {
            GetRedInput();
            SendInputState(gGameKeys.redLeft, gGameKeys.redRight, gGameKeys.redFire);
            GetGreenInput();
        }
    }
    else
    {
        GetGreenInput();
        if (gTwoPlayers)
            GetRedInput();
    }


    //•    Perform player/missile collission detection
    CollideShotsToEnemies();
    CollideShotsToPlayers();

    //•    If any enemy hit a boundry on the last run, switch directions
    if (gEnemiesChangeDirection)
    {
        DropEnemies();
        gEnemiesChangeDirection = 0;
        gEnemyTask = kEnemyDropping;
    }

    gEnemyGas = gWave + 1;

    //•    Get a reference to the back buffer
    DSpContext_GetBackBuffer(gDisplayContext, kDSpBufferKind_Normal, &backBuff);


    //•    Check the abort key
    ISpElement_GetNextEvent(gInputElements[abort], sizeof (event), &event, &wasEvent);
    if (gGotEndGameMessage || (wasEvent && (event.data == kISpButtonDown)))
    {
        if (gNetPlay && !gGotEndGameMessage)
            SendEndGame();
        EndGame(backBuff);
        return;
    }

    //•    Have all game objects perform their actions
    AdvanceEnemies();
    GameObjectListAdvance(gPlayerList);
    GameObjectListAdvance(gEnemyShotList);
    GameObjectListAdvance(gGreenPlayerShotList);
    GameObjectListAdvance(gRedPlayerShotList);
    GameObjectListAdvance(gMiscObjectList);

    //•    Draw all game objects
    GameObjectListDraw(gEnemyList, backBuff);
    GameObjectListDraw(gPlayerList, backBuff);
    GameObjectListDraw(gEnemyShotList, backBuff);
    GameObjectListDraw(gGreenPlayerShotList, backBuff);
    GameObjectListDraw(gRedPlayerShotList, backBuff);
    GameObjectListDraw(gMiscObjectList, backBuff);

    //•    Check for end of wave/game
    if ((gNumGreenPlayerLives < 1) && (gNumRedPlayerLives < 1))
    {
        EndGame(backBuff);
        return;
    }

    if (gNumEnemies < 1)
    {
        NextRound();
    }


    //•    Update the frame rate display information
    DisplayFrameRate();

    //•    Redraw the entire screen.  This is done last so that if the game over screen was drawn it gets blit for free
    GraphicsUpdateScreen();

}

static Boolean GetAutoFireButton(ISpElementReference inElement)
{
    OSStatus error;
    UInt32 input;
    Boolean wasEvent;
    Boolean fire = false;

    // poll
    error = ISpElement_GetSimpleState(inElement, &input);
    if (!error && (input == kISpButtonDown))
        { fire = true; }

    // but don't miss fast clicks or macros
    do
    {
        ISpElementEvent event;

        error = ISpElement_GetNextEvent(inElement, sizeof(ISpElementEvent), &event, &wasEvent);

        if (!error && wasEvent && (event.data == kISpButtonDown))
        {
            fire = true;
            break;
        }
    } while(wasEvent && !error);

    // flush the queue
    ISpElement_Flush(inElement);

    return fire;
}

void GetGreenInput(void)
{
    UInt32            input;

    if (!gNetPlay || (gNetPlay && gIAmHost))    // in netplay, the host is the green player, and the joiner the red
    {
        //•    Check the movement axis
        ISpElement_GetSimpleState(gInputElements[greenMovement], &input);

        gGameKeys.greenLeft = false;
        gGameKeys.greenRight = false;

        if (input < 0x2FFFFFFF)
            { gGameKeys.greenLeft = true; }
        else if (input > 0xBFFFFFFF)
            { gGameKeys.greenRight =  true; }
        else if (input < 0x5FFFFFFF)
        {
            gGreenAccum += ((float) input - (float) 0x5FFFFFFF) / (float) 0x3FFFFFFF;
             if (gGreenAccum < -1) { gGameKeys.greenLeft = true; gGreenAccum += 1; }
         }
         else if (input > 0x9FFFFFFF)
         {
            gGreenAccum += ((float) input - (float) 0x9FFFFFFF) / (float) 0x3FFFFFFF;
             if (gGreenAccum > 1) { gGameKeys.greenRight = true; gGreenAccum -= 1; }
         }

        //•    Check the fire button
        gGameKeys.greenFire = GetAutoFireButton(gInputElements[greenFire]);
    }
    else if (gNetPlay && !gIAmHost)    //wait for player 1's input
    {
        gReceivedInput = false;
        while (!gReceivedInput && !gGotEndGameMessage)
            HandleNetworking();
    }
}

void GetRedInput(void)
{
    UInt32            input;
    if (!gNetPlay || (gNetPlay && !gIAmHost))    // in netplay, the host is the green player, and the joiner the red
    {
        //•    Check the movement axis
        ISpElement_GetSimpleState(gInputElements[redMovement], &input);

        gGameKeys.redLeft = false;
        gGameKeys.redRight = false;

        if (input < 0x3FFFFFFF)
            { gGameKeys.redLeft = true; }
        else if (input > 0xAFFFFFFF)
            { gGameKeys.redRight =  true; }
        else if (input < 0x5FFFFFFF)
        {
            gRedAccum += ((float) input - (float) 0x5FFFFFFF) / (float) 0x2FFFFFFF;
             if (gRedAccum < -1) { gGameKeys.redLeft = true; gRedAccum += 1; }
         }
         else if (input > 0x9FFFFFFF)
         {
            gRedAccum += ((float) input - (float) 0x9FFFFFFF) / (float) 0x2FFFFFFF;
             if (gRedAccum > 1) { gGameKeys.redRight = true; gRedAccum -= 1; }
         }

        //•    Check the fire button
        gGameKeys.redFire = GetAutoFireButton(gInputElements[redFire]);
    }
    else if (gNetPlay && gIAmHost)    //wait for player 2's input
    {
        gReceivedInput = false;
        while (!gReceivedInput && !gGotEndGameMessage)
            HandleNetworking();
    }
}

//•    --------------------    AddPlayers

static void
AddPlayers(void)
{
Rect            r;
GameObjectPtr    go;

    go = GameObjectAllocate();
    if (! go)
        FatalError("Could not allocate player object.");

    GameObjectAddToList(&gPlayerList, go);

    SetRect(&r, 20, 0, 620, 0);
    GameObjectSetBounds(go, &r);
    GameObjectSetSprite(go, gSpriteCache[scPlayer]);

    go->kind = objectGreenPlayer;
    go->screenX = 20;
    go->screenY = 412;
    go->velocityH = kPlayerVelocity;
    go->velocityV = 0;
    go->action = GreenPlayerAction;

    //•    Sloppy way to do this, but hey, I'm in a hurry
    if (gTwoPlayers)
    {
        go = GameObjectAllocate();
        if (! go)
            FatalError("Could not allocate player 2 object.");

        GameObjectAddToList(&gPlayerList, go);

        SetRect(&r, 20, 0, 620, 0);
        GameObjectSetBounds(go, &r);
        GameObjectSetSprite(go, gSpriteCache[scPlayer2]);

        go->kind = objectRedPlayer;
        go->screenX = 640 - 20;
        go->screenY = 412;
        go->velocityH = kPlayerVelocity;
        go->velocityV = 0;
        go->action = RedPlayerAction;
    }
}

//•    --------------------    AddEnemies

static void
AddEnemies(void)
{
Rect            r;
GameObjectPtr    go;
int            i, j;
int            w, h;
int            x, x2, y;

    gNumEnemies = 0;

    //•    Find dimensions of enemy sprite so we can center the rows to begin with
    w = SpriteWidth(gSpriteCache[scEnemy], 0);
    w += kEnemyOffset;
    h = SpriteHeight(gSpriteCache[scEnemy], 0);
    h += kEnemyOffset;

    x2 = w * kNumEnemyColumns;
    x2 = 320 - (x2 / 2);

    y = 100;

    SetRect(&r, 20, 20, 620, 400);

    for (i = 0; i < kNumEnemyRows; i++)
    {
        x = x2;

        for (j = 0; j < kNumEnemyColumns; j++)
        {
            go = GameObjectAllocate();
            if (! go)
                FatalError("Could not allocate enemy object.");

            GameObjectAddToList(&gEnemyList, go);

            GameObjectSetBounds(go, &r);
            GameObjectSetSprite(go, gSpriteCache[scEnemy]);

            go->kind = objectEnemy;
            go->screenX = x;
            go->screenY = y;
            go->velocityH = kEnemyVelocity;
            go->velocityV = 0;
            go->action = EnemyAction;

            x += w;
            gNumEnemies++;
        }

        y += h;
    }
}

//•    --------------------    PlayerShoot

void
PlayerShoot(GameObjectPtr whichPlayer)
{
Rect            r;
GameObjectPtr    go;
GameObjectPtr    shotList;


    if (whichPlayer->kind == objectGreenPlayer)
    {
        if (gGreenPlayerShotList)
            return;
        else
            shotList = gGreenPlayerShotList;
    }
    else
    {
        if (gRedPlayerShotList)
            return;
        else
            shotList = gRedPlayerShotList;
    }

    SoundHandlerPlay(soundPlayerFire, whichPlayer->screenX, whichPlayer->screenY);

    go = GameObjectAllocate();
    if (! go)
        FatalError("Could not allocate player shot.");

    GameObjectAddToList(&shotList, go);

    SetRect(&r, 20, 0, 620, 0);
    GameObjectSetBounds(go, &r);
    GameObjectSetSprite(go, gSpriteCache[scPlayerShot]);

    go->screenX = whichPlayer->screenX;
    go->screenY = whichPlayer->screenY - SpriteHeight(whichPlayer->sprite, whichPlayer->frame) - 1;
    go->velocityH = 0;
    go->velocityV = kPlayerShotVelocity;
    go->action = PlayerShotAction;

    if (whichPlayer->kind == objectRedPlayer)
    {
        go->kind = objectRedPlayerShot;
        if (! gRedPlayerShotList)
            gRedPlayerShotList = shotList;
    }
    else
    {
        go->kind = objectGreenPlayerShot;
        if (! gGreenPlayerShotList)
            gGreenPlayerShotList = shotList;
    }
}

//•    --------------------    CollideShotsToEnemies

static void
CollideShotsToEnemies()
{
GameObjectPtr    shot;
GameObjectPtr    target;

    if (! gEnemyList)
        return;

    //•    Iterate over the green player shots
    if (gGreenPlayerShotList)
    {
        for (shot = gGreenPlayerShotList; shot; shot = shot->next)
        {
            //•    Iterate over the enemies
            for (target = gEnemyList; target; target = target->next)
            {
            Rect    u;    //•    Union of shot and enemy screen rects

                SectRect(&shot->screenRect, &target->screenRect, &u);
                if (! EmptyRect(&u))
                {
                    SoundHandlerPlay(soundEnemyHit, target->screenX, target->screenY);

                    shot->action = PlayerShotDestroy;
                    target->action = EnemyDestroy;
                    AddPoints(target->screenX, target->screenY);
                }
            }
        }
    }

    //•    Iterate over the red player shots
    if (gRedPlayerShotList)
    {
        for (shot = gRedPlayerShotList; shot; shot = shot->next)
        {
            //•    Iterate over the enemies
            for (target = gEnemyList; target; target = target->next)
            {
            Rect    u;    //•    Union of shot and enemy screen rects

                SectRect(&shot->screenRect, &target->screenRect, &u);
                if (! EmptyRect(&u))
                {
                    SoundHandlerPlay(soundEnemyHit, target->screenX, target->screenY);

                    shot->action = PlayerShotDestroy;
                    target->action = EnemyDestroy;
                    AddPoints(target->screenX, target->screenY);
                }
            }
        }
    }
}

//•    --------------------    CollideShotsToPlayers

static void
CollideShotsToPlayers(void)
{
GameObjectPtr    shot;
GameObjectPtr    target;
GameObjectPtr    next;

    if (! gEnemyShotList || ! gPlayerList)
        return;

    target = gPlayerList;
    next = target->next;
    while (target != nil)
    {
        if (target->refCon > 0)
            return;

        //•    Iterate over the enemy shots
        for (shot = gEnemyShotList; shot; shot = shot->next)
        {
        Rect    u;    //•    Union of shot and enemy screen rects

            SectRect(&shot->screenRect, &target->screenRect, &u);
            if (! EmptyRect(&u))
            {
                SoundHandlerPlay(soundPlayerHit,target->screenX, target->screenY);

                shot->action = EnemyShotDestroy;
                target->action = PlayerDestroy;

                if (target->kind == objectGreenPlayer)
                {
                    gNumGreenPlayerLives--;
                    if (gNumGreenPlayerLives < 1)
                        GameObjectRemoveFromList(&gPlayerList, target);
                }
                else
                {
                    gNumRedPlayerLives--;
                    if (gNumRedPlayerLives < 1)
                        GameObjectRemoveFromList(&gPlayerList, target);
                }
            }
        }

        target = next;
        next = target->next;
    }
}

//•    --------------------    AddPoints

static void
AddPoints(short x, short y)
{
Rect            r;
GameObjectPtr    go;

    gScore += 100L;

    go = GameObjectAllocate();
    if (! go)
        FatalError("Could not allocate player shot.");

    GameObjectAddToList(&gMiscObjectList, go);

    SetRect(&r, 0, 0, 640, 440);
    GameObjectSetBounds(go, &r);
    GameObjectSetSprite(go, gSpriteCache[scPoints]);

    go->screenX = x;
    go->screenY = y;
    go->velocityH = 0;
    go->velocityV = kPointsVelocity;
    go->action = PointsAction;
}

//•    --------------------    DisplayGameOver

static void
DisplayGameOver(CGrafPtr backBuff)
{
GrafPtr    oldPort;
Str255    str = "\pGame Over!";
short    width;
short    offset;

    GetPort(&oldPort);
    SetPort((GrafPtr) backBuff);

    TextFont(geneva);
    TextFace(bold);
    TextSize(48);

    //•    Find the width of our string
    width = StringWidth(str);

    //•    Find an offset that will center the string in the buffer
    offset = backBuff->portRect.right - backBuff->portRect.left;
    offset /= 2;
    offset -= width / 2;

    MoveTo(offset, 200);
    RGBForeColor(&rgbYellow);
    DrawString(str);

    MoveTo(offset - 2, 200);
    RGBForeColor(&rgbBlue);
    DrawString(str);

    MoveTo(offset - 4, 200);
    RGBForeColor(&rgbRed);
    DrawString(str);

    RGBForeColor(&rgbBlack);

    SetPort(oldPort);
    GraphicsSetRectDirty(&backBuff->portRect);
}

//•    --------------------    DropEnemies

static void
DropEnemies()
{
GameObjectPtr    current, next;

    gEnemyNewDirection = gEnemiesChangeDirection;

    do
    {
        current = gEnemyList;
        gNumEnemiesProcessed = 0;

        do
        {
            next = current->next;
            current->action(current);
            current = next;
        } while (next);
    } while (gNumEnemiesProcessed);

    gEnemyLevel++;
}

//•    --------------------    EnemyShoot

void
EnemyShoot(GameObjectPtr whichEnemy)
{
Rect            r;
GameObjectPtr    go;

    go = GameObjectAllocate();
    if (! go)
        FatalError("Could not allocate enemy shot.");

    SoundHandlerPlay(soundEnemyFire, whichEnemy->screenX, whichEnemy->screenY);

    GameObjectAddToList(&gEnemyShotList, go);

    SetRect(&r, 20, 0, 620, 412);
    GameObjectSetBounds(go, &r);
    GameObjectSetSprite(go, gSpriteCache[scEnemyShot]);

    go->screenX = whichEnemy->screenX;
    go->screenY = whichEnemy->screenY + 1;
    go->velocityH = 0;
    go->velocityV = kEnemyShotVelocity;
    go->action = EnemyShotAction;
}

//•    --------------------    AdvanceEnemies

static void
AdvanceEnemies()
{
GameObjectPtr    current, next;
unsigned long    oldProcessed;

    do
    {
        gNumEnemiesProcessed = 0;
        current = gEnemyList;

        do
        {
            oldProcessed = gNumEnemiesProcessed;
            next = current->next;
            current->action(current);

            //•    If we moved an alien, use up some alien gas
            if (oldProcessed != gNumEnemiesProcessed)
                gEnemyGas--;

            current = next;
        } while (next && gEnemyGas);

        //•    If no enemies were processed then they're all at the same level, so move on
        if (gNumEnemiesProcessed == 0)
        {
            gEnemyLevel++;

            if (gEnemyTask == kEnemyDropping)
                gEnemyTask = gEnemyNewDirection;
        }

    } while (gEnemyGas && (gNumEnemies > 0));
}

//•    --------------------    DisplayFrameRate

static void
DisplayFrameRate(void)
{
static unsigned long    lastTime = 0;
static unsigned long    frames = 0;
unsigned long        elapsedTime;
Str255            str;
GrafPtr            oldPort;
CGrafPtr            underlay;
GDHandle            device, oldDevice;
Rect                r;

    //•    Initialize the stats at the beginning of each game
    //•    gFrameRateBaseTime is reset in InitNewGame()
    if (gFrameRateBaseTime == 0)
    {
        gFrameRateBaseTime = TickCount();
        lastTime = 0L;
        frames = 0L;
    }

    //•    Bump the frame counter
    frames++;

    //•    Find the total elapsed time and convert it to seconds
    elapsedTime = TickCount() - gFrameRateBaseTime;

    if ( ( elapsedTime - lastTime ) > 120 )
    {
        lastTime = elapsedTime;
        elapsedTime /= 60;
        sprintf((char *) str + 1, "FPS:   %0.4ld", frames / elapsedTime);
        str[0] = strlen ((char *) str + 1);

        GraphicsGetUnderlayGrafPort(&underlay, &device);

        GetPort(&oldPort);
        oldDevice = GetGDevice();

        SetPort((GrafPtr) underlay);
        SetGDevice(device);

        RGBForeColor(&rgbBlack);
        SetRect(&r, 5, 420, 90, 435);
        PaintRect(&r);

        MoveTo(5, 435);
        TextFont(systemFont);
        TextFace(bold);
        TextSize(12);

        RGBForeColor(&rgbYellow);
        DrawString(str);
        RGBForeColor(&rgbBlack);

        SetPort(oldPort);
        SetGDevice(oldDevice);

        GraphicsSetUnderlayRectDirty(&r);
    }
}

//•    --------------------    EndGame

static void
EndGame(CGrafPtr backBuff)
{
    Boolean OKHit;

    ISpSuspend();
    DisplayGameOver(backBuff);
    GraphicsUpdateScreen();
    GraphicsPaused();
    ShowCursor();
    gGameInProgress = false;
    if (gNetGame)
    {
        if (gIAmHost)
            gNetState = kHosting;
        else
            gNetState = kJoining;
        OKHit = WaitForAllPlayers();
        if (OKHit == false)
            ShutdownNetworking();
        else
        {
            gNetState = kStarting;
            SendStartGame();
            InitNewGame(1);
        }
    }

}